#ifndef _CENTER_CLUB_MAMANAGER_H_
#define _CENTER_CLUB_MAMANAGER_H_

#include "Resource.h"
#include "ResourceManager.h"
#include "Singleton.h"
#include "String.h"
#include "Database/Field.h"
#include "DataManager.h"
#include "Threading/Mutex.h"



#define DB_NAME_GAMECLUB				"game_club"
#define DB_NAME_GAMECLUBMEMBER			"game_club_member"
#define DB_NAME_GAMECLUBMESSAGE			"game_club_message"
#define DB_NAME_GAMECLUBCONFIG			"game_club_config"
#define DB_NAME_GAMECLUBLOGS			"game_club_logs"
#define DB_NAME_GAMECLUBROOM			"game_club_room"
#define DB_NAME_GAMECLUBLABEL			"game_club_label"
#define DB_NAME_GAMECLUBREMARK			"game_club_remark"

class  Database;
class  CharPtr;
class  UserPtr;
class  WorldPacket;

struct CenterClub;
struct CenterClubMember;
struct CenterClubMessage;

struct CenterClub
{
	uint64 club_id;			// 俱乐部ID
	uint32 show_id;			// 俱乐部显示ID
	uint32 status;			// 状态
	uint32 agent_id;		// 代理商ID
	uint32 gz_id;			// 分区ID
	String name;			// 俱乐部名称
	String notice;			// 公告信息
	String desc;			// 简介信息
	
	uint32 rank;			// 星级
	
	String city;			// 市
	String town;			// 城
	String badge_url;		// 徽章
	uint32 badge_icon;		// 图标ID
	String create_time;		// 创建时间
	
	uint32 owner_pid;		// 房主PID
	String owner_nick;		// 房主昵称
	
	uint32 vice_president;	// 副会长人数
	uint32 curr_member;		// 当前成员数量
	uint32 max_member;		// 最大成员数量
	
	String expiry_date;		// 有效期（截止日期）
	uint64 activity_value;	// 活跃值
	
	String config_data;		// 配置数据
	
	CenterClub()
	{
		Init();
	}
	
	void Init()
	{
		club_id = 0;
		show_id = 0;
		status = 0;
		agent_id = 0;
		gz_id = 0;
		name = "";
		notice = "";
		desc = "";
		
		rank = 0;
		
		city = "";
		town = "";
		badge_url = "";
		badge_icon = 0;
		create_time = "";
		
		owner_pid = 0;
		owner_nick = "";
		
		vice_president = 0;
		curr_member = 0;
		max_member = 0;
		
		expiry_date = "";
		activity_value = 0;
		
		config_data = "";
	}

};

enum enClubListType
{
	enClubList_All = 0,		// 所有类型
	enClubList_Area = 1,	// 地区查询
	enClubList_Name = 2,	// 名字查询
	enClubList_Myself = 3,	// 自己加入的
};

// 创建俱乐部结果
enum enCreateClubResult
{
	enCreateClubResult_Sucess = 0,				// 成功
	enCreateClubResult_Failed = 1,				// 失败
	enCreateClubResult_Limit = 2,				// 创建数量达到上限
	enCreateClubResult_InvalidName = 3,			// 无效的名字
	enCreateClubResult_InvalidArea = 4,			// 无效的地区
	enCreateClubResult_ErrorRank = 5,			// 错误的等级
	enCreateClubResult_NeedDiamand = 6,			// 费用不足
	enCreateClubResult_DailyCreateLimit = 7,	// 每日创建次数超限
};

// 申请加入俱乐部结果
enum enRequireJoinClubResult
{
	enRequireJoinClubResult_Sucess = 0,			// 成功
	enRequireJoinClubResult_Failed = 1,			// 失败
	enRequireJoinClubResult_ErrorRefereeId = 2,	// 无效的推荐人ID
	enRequireJoinClubResult_InClub = 3,			// 玩家已经在公会中了
	enRequireJoinClubResult_ErrorClubId = 4,	// 无效的俱乐部ID
	enRequireJoinClubResult_ClubFull = 5,		// 公会成员已满
	enRequireJoinClubResult_AreadySend = 6,		// 已提交过申请
};

// 审核加入俱乐部结果
enum enReviewJoinClubResult
{
	enReviewJoinClubResult_Sucess = 0,			// 成功
	enReviewJoinClubResult_NotExist = 1,		// 消息不存在
	enReviewJoinClubResult_WuQuan = 2,			// 无权操作
	enReviewJoinClubResult_NoClub = 3,			// 消息所属公会不存在
	enReviewJoinClubResult_ClubFull = 4,		// 公会成员已满
	enReviewJoinClubResult_Exist = 5,			// 玩家已在公会中
};

// 俱乐部带入分数结果
enum enClubTakeinResult
{
	enClubTakeinResult_Sucess = 0,				// 成功
	enClubTakeinResult_Failed = 1,				// 失败
	enClubTakeinResult_NoClub = 2,				// 公会不存在
	enClubTakeinResult_NotMember = 3,			// 不是公会成员
	enClubTakeinResult_NeedCoins = 4,			// 游戏币不足
};

// 审核俱乐部带入结果
enum enReviewTakeinResult
{
	enReviewTakeinResult_Sucess = 0,			// 成功
	enReviewTakeinResult_Failed = 1,			// 失败
	enReviewTakeinResult_ErrorMessage = 2,		// 消息不存在
	enReviewTakeinResult_WuQuan = 3,			// 权限不够
	enReviewTakeinResult_NoClub = 4,			// 公会不存在
};

// 退分结果
enum enReturnCoinsResult
{
	enReturnCoinsResult_Sucess = 0,				// 成功
	enReturnCoinsResult_Failed = 1,				// 失败
	enReturnCoinsResult_Playing = 2,			// 游戏中
	enReturnCoinsResult_NotMember = 3,			// 不是成员
	enReturnCoinsResult_NoCoins = 4,			// 没有积分
	enReturnCoinsResult_NoQuanXian = 5,			// 权限不足
	enReturnCoinsResult_WaitGameFinish = 6,		// 退分操作已提交，等待玩家游戏结束
};

// 审核消息类型
enum enReviewMessageType
{
	enReviewMessageType_Join = 1,				// 审核加入消息
	enReviewMessageType_Takein = 2,				// 审核带入消息
	enReviewMessageType_Change = 3,				// 职位变更消息
	enReviewMessageType_Kickout = 4,			// 公会踢出消息
};

// 通用操作类型
enum enOperatorType
{
	enOperatorType_None = 0,					// 无效
	enOperatorType_Agree = 1,					// 同意/通过
	enOperatorType_Refuse = 2,					// 拒绝
};

// 购买会员结果
enum enBuyPlayerVipResulr
{
	enBuyPlayerRankResulr_Sucess = 0,			// 成功
	enBuyPlayerRankResulr_Failed = 1,			// 失败
	enBuyPlayerRankResulr_NoConfig = 2,			// 未找到配置
	enBuyPlayerRankResulr_NeedDiamand = 3,		// 费用不足
	
};

// 购买俱乐部星级结果
enum enBuyClubRankResult
{
	enBuyClubRankResult_Sucess = 0,				// 成功
	enBuyClubRankResult_Failed = 1,				// 失败
	enBuyClubRankResult_NoConfig = 2,			// 未找到配置
	enBuyClubRankResult_NeedDiamand = 3,		// 费用不足
	enBuyClubRankResult_NoClub = 4,				// 公会不存在
	enBuyClubRankResult_NotMember = 5,			// 不是公会成员
	enBuyClubRankResult_NoQuanXian = 6,			// 权限不够
};

// 玩家退出俱乐部结果
enum enPlayerExitClubResult
{
	enPlayerExitClubResult_Sucess = 0,			// 成功
	enPlayerExitClubResult_NoClub = 1,			// 公会不存在
	enPlayerExitClubResult_NotClubMember = 2,	// 不是公会成员
};

// 俱乐部玩家操作模式
enum enClubOpMemberMode
{
	enClubOpMemberMode_ChangeQuanXian = 1,		// 权限调整
	enClubOpMemberMode_KickOutClub = 2,			// 踢出公会
};

// 俱乐部玩家操作结果
enum enClubOpMemberResult
{
	enClubOpMemberResult_Sucess = 0,			// 成功
	enClubOpMemberResult_NoClub = 1,			// 公会不存在
	enClubOpMemberResult_NoMember = 2,			// 不是公会成员
	enClubOpMemberResult_NoQuanXian = 3,		// 权限不够
	enClubOpMemberResult_CannotOpSelf = 4,		// 不能操作自己
	enClubOpMemberResult_ErrorOp = 5,			// 无效的操作
	enClubOpMemberResult_LimitZhiWei = 6,		// 职位数量达到上限
};

// 聊天结果信息
enum enClubChatResult
{
	enClubChatResult_Sucess = 0,				// 成功
	enClubChatResult_NoClub = 1,				// 公会不存在
	enClubChatResult_NotMember = 2,				// 不是公会成员
	enClubChatResult_TooLong = 3,				// 消息内容过长
};

// 购买商品结果
enum enClubBuyGoodsResult
{
	enClubBuyGoodsResult_Sucess = 0,			// 购买成功
	enClubBuyGoodsResult_ErrorGoodsId = 1,		// 无效的商品ID
	enClubBuyGoodsResult_NeedDiamand = 2,		// 身上钻石不足
};

// 解散公会
enum enClubDissolveResult
{
	enClubDissolveResult_Sucess = 0,			// 成功
	enClubDissolveResult_NoClub = 1,			// 公会不存在
	enClubDissolveResult_NotPresident = 2,		// 不是公会会长
};

// 修改公会信息
enum enClubInfoChangeResult
{
	enClubInfoChangeResult_Sucess = 0,			// 成功
	enClubInfoChangeResult_NoClub = 1,			// 公会不存在
	enClubInfoChangeResult_NotManager = 2,		// 不是管理员
	enClubInfoChangeResult_ErrorType = 3,		// 无效的操作
};

// 创建俱乐部快捷开房配置
enum enClubCreateFastMode
{
	enClubCreateFastMode_Sucess = 0,			// 成功
	enClubCreateFastMode_Failed = 1,			// 失败
	enClubCreateFastMode_Max = 2,				// 数量达到上限
	enClubCreateFastMode_Same = 3,				// 已有相同配置
};

// 移除俱乐部快捷开房配置
enum enClubDeleteFastMode
{
	enClubDeleteFastMode_Sucess = 0,			// 成功
	enClubDeleteFastMode_ErrorIndex = 1,		// 无效的索引
};

//牌局流程锁
#define WGS_CLUBROOM_MUTEX_NAME club_mutex_name
#define WGS_CLUBROOM_MUTEX mutable boost::mutex WGS_CLUBROOM_MUTEX_NAME;
#define WGS_CLUBROOM_LOCK		boost::lock_guard<boost::mutex> wgsClubMutexLock(WGS_CLUBROOM_MUTEX_NAME);

//-----------------------俱乐部--------------------------
class  SERVER_DECL CenterClubManager:public Singleton<CenterClubManager>
{
public:
	WGS_CLUBROOM_MUTEX
	
	//==========================资源对象操作相关=================================
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 添加一条CenterClub记录
	 * @参数
	 * 	@cc	CenterClub对象
	 */
	bool AddCenterClub(CenterClub & cc);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 
	 * @参数
	 * 	@cGF CenterClub对象
	 */
	bool UpdateCenterClub(const CenterClub & cGF);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据Fields的值来更新多个字段
	 * @参数
	 * 	@cgf_id	PD_ID
	 *	@fields	字段键值对,格式：fields["key1"] = 1; fields["key2"] = 2;...
	 */
	bool UpdateCenterClub(Fields * fields, const char * QueryString, ...);
	bool UpdateCenterClub(const uint64 & cc_id, Fields * fields);
	
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据PD_ID获取一条PD数据
	 * @参数
	 *  @cgf_id CenterClub id
	 * 	@cc	CenterClub对象
	 */
	bool GetCenterClub(const uint64 & cc_id, CenterClub * cc);
	bool GetCenterClubByShowID(const uint32 & show_id, CenterClub * cc);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据查询SQL，获取PD列表
	 * @参数
	 * 	@lstFriend	CenterClub对象列表
	 *  @query 查询语句条件
	 */
	uint32 GetCenterClubList(std::list<CenterClub> * lstClub, const char * query,...);
	
	//==========================资源对象操作相关=================================
	
	//===========================俱乐部逻辑相关==================================
	// 获取俱乐部信息（发包）
	void GetClubHallInfo(CharPtr & pChr, const uint64 & club_id);
	void GetClubNormalInfo(CharPtr & pChr, const uint64 & club_id);
	// 获得俱乐部列表（通过名字查询）
	void GetClubNormalInfo(CharPtr & pChr, String & strName);
	// 获得俱乐部列表-满天飞（通过名字/ID查询）
	void GetClubNormalInfoMTF(CharPtr & pChr, String & strName);
	
	// 获得满天飞俱乐部信息（发包）
	void GetMTFClubNormalInfo(CharPtr & pChr, const uint64 &  club_id);
	
	// 获取俱乐部列表信息（通过地区查询）
	void GetClubListInfo(CharPtr & pChr, String & strArea);
	// 获得自己所在俱乐部列表
	void GetSelfClubList(CharPtr & pChr);
	// 获得自己所在俱乐部列表-满天飞
	void GetSelfClubListMTF(CharPtr & pChr);
	// 获取玩家创建的俱乐部数量
	uint32 PlayerCreateClubCount(CharPtr & pChr);
	
	// 创建俱乐部
	bool CreateClub(CharPtr & pChr, const uint32 & badge_icon, String & name, String & city);
	// 创建满天飞俱乐部
	bool CreateClubMTF(CharPtr & pChr, String & name, String & dsec);
	// 俱乐部加入申请
	bool RequireJoinClub(CharPtr & pChr, const uint64 & club_id, const uint32 & referee_id, String & content);
	// 玩家退出俱乐部
	bool PlayerExitClub(CharPtr & pChr, const uint64 & club_id);
	
	// 审核加入俱乐部玩家
	bool DealMemberJoinClub(CharPtr & pChr, const uint64 & club_messageId, const uint8 & mode);
	
	// 带入分数
	bool PlayerTakeinScore(CharPtr & pChr, const uint64 & club_id, const uint32 & score);
	// 审核玩家带入分数
	bool DealTakeinScore(CharPtr & pChr, const uint64 & club_messageId, const uint8 & mode);
	
	// 退分
	bool PlayerReturnScore(CharPtr & pChr, const uint64 & club_id, const uint32 & target_pid = 0);
	
	// 购买会员
	bool PlayerBuyRank(CharPtr & pChr, const uint8 & rank);
	// 升级俱乐部星级
	bool PlayerBuyClubRank(CharPtr & pChr, const uint64 & club_id, const uint8 & rank);
	
	// 操作玩家权限
	bool ChangePlayerQuanXian(CharPtr & pChr, const uint64 & club_id, const uint32 & pid, const uint8 & member_type);
	// 踢出玩家
	bool KickoutPlayer(CharPtr & pChr, const uint64 & club_id, const uint32 & pid);
	
	// 俱乐部聊天
	bool PlayerChat(CharPtr & pChr, const uint64 & club_id, String & content);
	
	// 广播公会所有成员
	bool BroadcastClubPacket(WorldPacket * packet, const uint64 & club_id);
	
	// 获得发现的俱乐部组局列表
	bool GetMyClubRoomList(CharPtr & pChr);
	
	// 购买商品
	bool BuyClubGoods(CharPtr & pChr, const uint32 & goods_id);
	
	// 解散公会
	bool DissolveClub(CharPtr & pChr, const uint64 & club_id);
	// 修改公会信息
	bool ChangeClubInfo(CharPtr & pChr, const uint32 & club_id, const uint32 & type, String & strData);
	
	// 增加魅力值
	bool AddClubPlayerCharm(CharPtr & pChr, const uint32 & num);
	// 增加活跃值
	bool AddClubActivityValue(const uint64 & club_id, const uint64 & count);
	
	// 获取玩家详细信息
	bool GetClubPlayerDetails(CharPtr & pChr, const uint32 & dest_pid);
	
	// 获得俱乐部活动经费
	uint32 GetClubActivityValue(const uint64 & club_id);
	// 增加俱乐部活动经费
	bool AddClubActivityValue(const uint64 & club_id, const uint32 & num);
	// 减少俱乐部活动经费
	bool ReduceClubActivityValue(const uint64 & club_id, const uint32 & num);
	
	// 根据玩家更新俱乐部经费
	bool UpdateClubActivityValueByCraeter(CharPtr & pChr);
	// 获取俱乐部创建者PID
	uint32 GetClubCreaterPid(const uint32 & club_id);
	
	// 创建快捷开房配置
	bool CreateFastCreateMode(CharPtr & pChr, const uint32 & club_id, String & strConfig);
	// 移除快捷开放配置
	bool DeleteFastCreateMode(CharPtr & pChr, const uint32 & club_id, const uint8 & del_index);
	// 获得快捷开房配置
	bool GetFastBuildMode(CharPtr & pChr, const uint32 & show_id);
	
	// 永久封停俱乐部
	bool ManagerStopClub(const uint32 & show_id);
	
	//===========================俱乐部逻辑相关==================================
public:
	std::map<uint32, uint32> m_mapReviewJoinTiemr;
	std::map<uint32, uint32> m_mapReviewTakeinTiemr;
	std::map<uint32, uint32> m_mapReviewExitCoinsTiemr;
	
};

#define   sCenterClubMgr     CenterClubManager::getSingleton()

struct CenterClubMember
{
	uint64 member_id;		// 成员ID
	uint32 status;			// 状态
	uint32 agent_id;		// 代理商ID
	uint32 gz_id;			// 分区ID
	uint32 club_id;			// 俱乐部ID
	uint32 type;			// 类型
	uint32 pid;				// 玩家平台ID
	uint32 play_loop;		// 游戏局数
	uint32 takein_coins;	// 带入分数
	uint32 curr_score;		// 当前分数
	int32 curr_result;		// 当前成绩
	uint32 total_pump;		// 当前抽水
	
	String pump_info;		// 抽水详情
	
	String nick;			// 昵称
	String icon_url;		// 头像地址
	String addr;			// 玩家物理地址
	
	uint32 referee_pid;		// 推荐人PID
	String referee_nick;	// 推荐人昵称
	String referee_icon;	// 推荐人头像
	
	String create_time;		// 创建时间
	String exit_time;		// 退出时间
	String ll_time;			// 最后一次登录时间
	
	CenterClubMember()
	{
		Init();
	}
	
	void Init()
	{
		member_id = 0;
		status = 0;
		agent_id = 0;
		gz_id = 0;
		club_id = 0;
		type = 0;
		pid = 0;
		play_loop = 0;
		takein_coins = 0;
		curr_score = 0;
		curr_result = 0;
		total_pump = 0;
		
		pump_info = "";
		nick = "";
		icon_url = "";
		addr = "";
		
		referee_pid = 0;
		referee_nick = "";
		referee_icon = "";
		
		create_time = "";
		exit_time = "";
		ll_time = "";
	}
	
};

enum enClubMemberType
{
	enClubMemberType_Normal = 0,		// 普通成员
	enClubMemberType_VicePresident = 1,	// 副会长
	enClubMemberType_President = 2,		// 会长
};

//牌局流程锁
#define WGS_CLUBMEMBER_MUTEX_NAME chn_clubmember_mutex
#define WGS_CLUBMEMBER_MUTEX mutable boost::mutex WGS_CLUBMEMBER_MUTEX_NAME;
#define WGS_CLUBMEMBER_LOCK		boost::lock_guard<boost::mutex> wgsClubMemberMutexLock(WGS_CLUBMEMBER_MUTEX_NAME);

// 俱乐部成员
class  SERVER_DECL CenterClubMemberManager:public Singleton<CenterClubMemberManager>
{
public:
	WGS_CLUBMEMBER_MUTEX
	//==========================资源对象操作相关=================================
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 添加一条CenterClub记录
	 * @参数
	 * 	@cc	CenterClubMember对象
	 */
	bool AddCenterClubMember(CenterClubMember & ccMember);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 
	 * @参数
	 * 	@cGF CenterClubMember对象
	 */
	bool UpdateCenterClubMember(const CenterClubMember & ccMember);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据Fields的值来更新多个字段
	 * @参数
	 * 	@cgf_id	PD_ID
	 *	@fields	字段键值对,格式：fields["key1"] = 1; fields["key2"] = 2;...
	 */
	bool UpdateCenterClubMember(Fields * fields, const char * QueryString, ...);
	bool UpdateCenterClubMember(const uint64 & ccMember_id, Fields * fields);
	
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据PD_ID获取一条PD数据
	 * @参数
	 *  @cgf_id CenterClubMember id
	 * 	@cgf	CenterClubMember对象
	 */
	bool GetCenterClubMember(const uint64 & ccMember_id, CenterClubMember * ccMessage);
	bool GetCenterClubMember(const uint64 & club_id, const uint32 & pid, CenterClubMember * ccMember);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据查询SQL，获取PD列表
	 * @参数
	 * 	@lstFriend	CenterClubMember对象列表
	 *  @query 查询语句条件
	 */
	uint32 GetCenterClubMemberList(std::list<CenterClubMember> * lstClubMember, const char * query,...);
	uint32 GetTargetClubMemberList(std::list<CenterClubMember> * lstClubMember, const uint64 & club_id);
	
	// 查询结果集数量
	uint32 GetCenterClubMemberDBCount(const char * query,...);
	
	//==========================资源对象操作相关=================================
	
	//============================逻辑操作相关===================================
	// 更新玩家会员最后登录时间
	void UpdateMemberOnlineLastLoginTime(const uint32 & pid);
	// 更新玩家会员离线状态
	void UpdateMemberOffline(const uint32 & pid);
	// 玩家是否在公会中
	bool IsPlayerInClub(const uint64 & club_id, const uint32 & pid);
	// 公会增加成员
	bool ClubAddMember(CenterClub & cc, const uint32 & pid, const uint32 & referee_id, const uint32 & member_type);
	// 公会减少成员
	bool ClubReduceMember(CenterClub & cc, const uint32 & pid, bool bJieSan = false);
	// 解散公会成员
	bool ClubClearAllMembrt(CenterClub & cc);
	// 玩家是否公会管理员
	bool IsPlayerClubManager(const uint64 & club_id, const uint32 & pid);
	// 玩家是否公会会长
	bool IsPlayerClubPresident(const uint64 & club_id, const uint32 & pid);
	// 获取玩家成员列表（成绩排序）
	bool GetMemberListByChengji(CharPtr & pChr, const uint64 & club_id);
	// 成员完成一局游戏
	bool MemberComplateGame(const uint64 & club_id, const uint32 & pid, const int32 & winLose, const uint32 & pump_coins);
	// 获得玩家某个公会的带入金额
	uint32 GetMemberTakeinCoins(const uint32 & club_id, const uint32 & pid);
	// 广播消息给管理员
	void BroadcastClubManagerMemberPacket(const uint64 & club_id, WorldPacket * packet);
	
	// 获得玩家某个公会的当前金额
	uint32 GetMemberCurrCoins(const uint32 & club_id, CharPtr & pChr);
	// 增加玩家俱乐部当前积分
	bool AddMemberCurrCoins(const uint32 & club_id, CharPtr & pChr, const uint32 & num);
	// 减少玩家俱乐部当前积分
	bool ReduceMemberCurrCoins(const uint32 & club_id, CharPtr & pChr, const uint32 & num);
	// 设定房间输赢数据
	void SetClubRoomWinlose(const uint32 & club_id, const uint32 & club_room_id, const uint32 & pid, const int32 & total_win);
	// 获得房间输赢
	int32 GetClubRoomWinlose(const uint32 & club_id, const uint32 & club_room_id, const uint32 & pid);
	// 清除房间抽水数据
	void ClearClubRoomWinlose(const uint32 & club_id, const uint32 & club_room_id, const uint32 & pid);
	
	//============================逻辑操作相关===================================
};

#define   sCenterClubMemberMgr     CenterClubMemberManager::getSingleton()

struct CenterClubMessage
{
	uint64 message_id;		// 消息ID
	uint32 status;			// 状态
	uint32 agent_id;		// 代理商ID
	uint64 club_id;			// 俱乐部ID
	uint32 type;			// 类型
	
	uint32 owner_cid;		// 源角色ID
	uint32 owner_pid;		// 源PID
	String owner_nick;		// 源昵称
	String owner_icon;		// 源头像
	
	uint32 target_pid;		// 目标PID
	String target_nick;		// 目标昵称
	String target_icon;		// 目标头像
	
	uint32 takein_coins;	// 带入金额
	String message;			// 消息内容
	String create_time;		// 创建时间
	String finish_time;		// 结束时间
	
	CenterClubMessage()
	{
		Init();
	}
	
	void Init()
	{
		message_id = 0;
		status = 0;
		agent_id = 0;
		club_id = 0;
		type = 0;
		
		owner_cid = 0;
		owner_pid = 0;
		owner_nick = "";
		owner_icon = "";
		
		target_pid = 0;
		target_nick = "";
		target_icon = "";
		
		takein_coins = 0;
		message = "";
		create_time = "";
		finish_time = "";
	}
	
};

enum enClubMessageType
{
	enClubMessageType_Review = 1,		// 审核消息
	enClubMessageType_Takein = 2,		// 带入消息
	enClubMessageType_System = 3,		// 系统消息
	enClubMessageType_RoomCount = 4,	// 未结束房间数量
	enClubMessageType_ReviewAgree = 5,	// 审核被同意
	enClubMessageType_ReviewRefuse = 6,	// 审核被拒绝
	enClubMessageType_TakeinAgree = 7,	// 带入被同意
	enClubMessageType_TakeinRefuse = 8,	// 带入被拒绝
	enClubMessageType_Chat = 100,		// 聊天消息
};

// 审核消息状态
enum enReviewMessageStatus
{
	enReviewMessageStatus_Process = 0,	// 请求中
	enReviewMessageStatus_Agree = 1,	// 通过
	enReviewMessageStatus_Refuse = 2,	// 拒绝
};

// 俱乐部消息
class  SERVER_DECL CenterClubMessageManager:public Singleton<CenterClubMessageManager>
{
public:
	//==========================资源对象操作相关=================================
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 添加一条CenterClubMessage记录
	 * @参数
	 * 	@cc	CenterClubMessage对象
	 */
	bool AddCenterClubMessage(CenterClubMessage & ccMessage);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 
	 * @参数
	 * 	@cGF CenterClubMessage对象
	 */
	bool UpdateCenterClubMessage(const CenterClubMessage & ccMessage);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据Fields的值来更新多个字段
	 * @参数
	 * 	@cgf_id	PD_ID
	 *	@fields	字段键值对,格式：fields["key1"] = 1; fields["key2"] = 2;...
	 */
	bool UpdateCenterClubMessage(Fields * fields, const char * QueryString, ...);
	bool UpdateCenterClubMessage(const uint64 & ccMessage_id, Fields * fields);
	
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据PD_ID获取一条PD数据
	 * @参数
	 *  @ccMessage_id 	CenterClubMessage
	 * 	@ccMessage		CenterClubMessage对象
	 */
	bool GetCenterClubMessage(const uint64 & ccMessage_id, CenterClubMessage * ccMessage);
	
	/**
	 * @创建时间 2016-07-13
	 * @创建人 Roach
	 * @函数作用 根据查询SQL，获取PD列表
	 * @参数
	 * 	@lstFriend	CenterClubMessage对象列表
	 *  @query 查询语句条件
	 */
	uint32 GetCenterClubMessageList(std::list<CenterClubMessage> * lstClubMessage, const char * query,...);
	
	//==========================资源对象操作相关=================================
	
	//============================逻辑操作相关===================================
	// 获得某俱乐部最近N条聊天消息（默认取10条）
	void GetClubNearestMessages(const uint64 & club_id, std::list<CenterClubMessage> * lstClubMessage, const uint32 & limit_count = 10);
	// 俱乐部审核消息列表
	void GetClubReviewMessages(CharPtr & pChr, const uint64 & club_id);
	void GetClubReviewMessagesCount(CharPtr & pChr, const uint64 & club_id);
	// 俱乐部带入消息列表
	void GetClubTakeinMessages(CharPtr & pChr, const uint64 & club_id);
	void GetClubTakeinMessagesCount(CharPtr & pChr, const uint64 & club_id);
	// 添加审核消息
	bool AddReviewMessage(const uint64 & club_id, UserPtr & pUser, String & content, const uint32 & referee_id, String & strRefereeName);
	// 添加带入消息
	bool AddTakeinCoinsMessage(const uint64 & club_id, UserPtr & pUser, const uint32 & coins);
	
	// 添加聊天消息（玩家/系统）
	uint64 AddChatMessage(CharPtr & pChr, String & content, const uint64 & club_id);
	bool AddSystemChatMessage(String & content, const uint32 & agent_id, const uint64 & club_id);
	
	// 请求聊天信息列表
	bool GetClubChatMessageList(CharPtr & pChr, const uint64 & club_id, const uint32 & limit_count);
	
	//============================逻辑操作相关===================================
};

#define   sCenterClubMessageMgr     CenterClubMessageManager::getSingleton()

struct CenterClubConfig
{
	uint32 config_id;			// 配置ID
	uint32 status;				// 状态
	uint32 type;				// 类型（1 玩家 2 俱乐部）
	uint32 agent_id;			// 代理商ID
	uint32 rank;				// 等级或者星级
	uint32 pay_diamand;			// 需要支付的钻石
	uint32 need_diamand;		// 创建时身上需要拥有的钻石数量
	uint32 valid_days;			// 有效期（单位：天）
	uint32 max_club_add;		// 俱乐部最大数量增加
	uint32 max_member_add;		// 俱乐部最大成员数量增加
	uint32 give_coins;			// 赠送金币
	uint32 max_room_add;		// 同时创建的最大房间数量增加
	uint32 vice_president_add;	// 副会长数量增加
	uint32 max_join_club;		// 最大可加入俱乐部数量（0 表示不限制）
	
	CenterClubConfig()
	{
		Init();
	}
	
	void Init()
	{
		config_id = 0;
		status = 0;
		type = 0;
		agent_id = 0;
		rank = 0;
		pay_diamand = 0;
		need_diamand = 0;
		valid_days = 0;
		max_club_add = 0;
		max_member_add = 0;
		give_coins = 0;
		max_room_add = 0;
		vice_president_add = 0;
		max_join_club = 0;
	}
};

enum enCenterClubConfigType
{
	enCenterClubConfigType_Player = 1,	// 玩家
	enCenterClubConfigType_Club = 2,	// 俱乐部
	enCenterClubConfigType_Shop = 3,	// 商城
};

// 俱乐部配置
class  SERVER_DECL CenterClubConfigManager:public Singleton<CenterClubConfigManager>
{
public:
	// 获得俱乐部配置列表
	uint32 GetCenterClubConfigList(std::list<CenterClubConfig> * lstConfig, const char * query,...);
	
	// 获得单条配置记录
	CenterClubConfig GetCenterClubConfig(const uint32 & type, const uint32 & rank, const uint32 & agent_id = 0);
	// 获得商品配置信息
	CenterClubConfig GetCenterClubGoodsConfig(const uint32 & goods_id, const uint32 & agent_id = 0);
};

#define   sCenterClubConfigMgr     CenterClubConfigManager::getSingleton()


struct CenterClubLog
{
	uint64 log_id;
	uint32 status;
	String status_desc;
	
	uint32 type;
	uint32 agent_id;
	uint64 club_id;
	
	uint32 pid;
	String nick;
	String icon;
	
	int32 data1;
	int32 data2;
	int32 data3;
	int32 data4;
	int32 data5;
	int32 data6;
	int32 data7;
	int32 data8;
	
	uint32 udata1;
	uint32 udata2;
	uint32 udata3;
	uint32 udata4;
	
	float fdata1;
	float fdata2;
	float fdata3;
	float fdata4;
	
	String create_time;
	
	CenterClubLog()
	{
		Init();
	}
	
	void Init()
	{
		log_id = 0;
		status = 0;
		
		status_desc = "";
		type = 0;
		agent_id = 0;
		club_id = 0;
		
		pid = 0;
		nick = "";
		icon = "";
		
		data1 = 0;
		data2 = 0;
		data3 = 0;
		data4 = 0;
		data5 = 0;
		data6 = 0;
		data7 = 0;
		data8 = 0;
		
		udata1 = 0;
		udata2 = 0;
		udata3 = 0;
		udata4 = 0;
		
		fdata1 = 0.0f;
		fdata2 = 0.0f;
		fdata3 = 0.0f;
		fdata4 = 0.0f;
		
		create_time = "";
	}
	
};

enum enClubLogType
{
	enClubLogType_Review = 1,		// 审核
	enClubLogType_Takein = 2,		// 带入
	enClubLogType_ExitCoins = 3,	// 退分
	enClubLogType_Activity = 4,		// 活跃
	enClubLogType_TakeinPump = 5,	// 手续费
};

// 俱乐部日志记录
class  SERVER_DECL CenterClubLogsManager:public Singleton<CenterClubLogsManager>
{
public:
	//==========================资源对象操作相关=================================
	// 添加俱乐部日志记录
	bool AddCenterClubLog(CenterClubLog & ccLog);
	
	// 更新俱乐部日志记录
	bool UpdateCenterClubLog(const CenterClubLog & ccLog);
	bool UpdateCenterClubLog(Fields * fields, const char * QueryString, ...);
	bool UpdateCenterClubLog(const uint64 & log_id, Fields * fields);
	
	// 获得俱乐部日志
	bool GetCenterClubLog(const uint64 & ccLog_id, CenterClubLog * ccLog);
	// 获得俱乐部日志列表
	uint32 GetCenterClubLogList(std::list<CenterClubLog> * lstClubLog, const char * query,...);
	
	//============================逻辑操作相关===================================
	// 增加审核日志
	bool AddReviewLog(CenterClubMessage & ccMessage, const uint8 & result);
	// 增加带入日志
	bool AddTakeinLog(CenterClubMessage & ccMessage, const uint8 & result);
	// 增加退分日志
	bool AddExitCoinsLog(CenterClubMember & ccMember);
	// 增加活跃变化日志
	bool AddActivityChangeLog(CenterClub & ccClub, const uint32 & num);
	// 增加手续费日志
	bool AddTakeinPumpLog(CenterClubMember & ccMember, const uint32 & num);
	
	// 获取审核历史
	bool GetReviewLogs(CharPtr & pChr, const uint64 & club_id, const uint8 & type);
	// 获取退分历史
	bool GetExitCoinsLogs(CharPtr & pChr, const uint64 & club_id);
};

#define   sCenterClubLogMgr     CenterClubLogsManager::getSingleton()



struct CenterClubRoom
{
	uint64 room_id;		// 房间ID
	uint32 status;		// 状态
	uint32 type;		// 类型（1 匹配房 2 选座房）
	uint64 club_id;		// 俱乐部ID
	uint32 agent_id;	// 代理商ID
	uint32 pid;			// 创建玩家PID
	uint32 curr_member;	// 当前玩家数量
	uint32 max_member;	// 允许进入的最大玩家数量
	String play_mode;	// 玩法配置
	String expiry_date;	// 过期时间
	
	uint32 data1;		// 附加数据1
	uint32 data2;		// 附加数据2
	uint32 data3;		// 附加数据3
	uint32 data4;		// 附加数据4
	uint32 data5;		// 附加数据5
	uint32 data6;		// 附加数据6
	uint32 data7;		// 附加数据7
	uint32 data8;		// 附加数据8
	
	String sdata1;		// 附加字符串1
	String sdata2;		// 附加字符串2
	String sdata3;		// 附加字符串3
	String sdata4;		// 附加字符串4
	String sdata5;		// 附加字符串5
	String sdata6;		// 附加字符串6
	String sdata7;		// 附加字符串7
	String sdata8;		// 附加字符串8
	
	String create_time;	// 创建时间
	String end_time;	// 结束时间
	
	CenterClubRoom()
	{
		Init();
	}
	
	void Init()
	{
		room_id = 0;		// 房间ID
		status = 0;			// 状态
		type = 0;			// 类型（1 匹配房 2 选座房）
		club_id = 0;		// 俱乐部ID
		agent_id = 0;		// 代理商ID
		pid = 0;			// 创建玩家PID
		curr_member = 0;	// 当前玩家数量
		max_member = 0;		// 允许进入的最大玩家数量
		play_mode = "";		// 玩法配置
		expiry_date = "";	// 过期时间
		
		data1 = 0;		// 附加数据1
		data2 = 0;		// 附加数据2
		data3 = 0;		// 附加数据3
		data4 = 0;		// 附加数据4
		data5 = 0;		// 附加数据5
		data6 = 0;		// 附加数据6
		data7 = 0;		// 附加数据7
		data8 = 0;		// 附加数据8
		
		sdata1 = "";		// 附加字符串1
		sdata2 = "";		// 附加字符串2
		sdata3 = "";		// 附加字符串3
		sdata4 = "";		// 附加字符串4
		sdata5 = "";		// 附加字符串5
		sdata6 = "";		// 附加字符串6
		sdata7 = "";		// 附加字符串7
		sdata8 = "";		// 附加字符串8
		
		create_time = "";	// 创建时间
		end_time = "";		// 结束时间
	}
};

enum enClubRoomType
{
	enClubRoomType_Pipei = 1,	// 匹配场
	enClubRoomType_XuanZuo = 2,	// 选座场
};

enum enCreateClubRoomResult
{
	enCreateClubRoomResult_Sucess = 0,			// 成功
	enCreateClubRoomResult_ErrorParmas = 1,		// 无效的参数
	enCreateClubRoomResult_NotManager = 2,		// 不是管理员
	enCreateClubRoomResult_LimitCount = 3,		// 创建数量超过限制
};

// 俱乐部房间
class  SERVER_DECL CenterClubRoomManager:public Singleton<CenterClubRoomManager>
{
public:
	CenterClubRoomManager();
	
public:
	//==========================资源对象操作相关=================================
	// 添加俱乐部日志记录
	bool AddCenterClubRoom(CenterClubRoom & ccRoom);
	// 更新房间数据
	bool UpdateCenterClubRoom(const CenterClubRoom & ccRoom);
	// 获得房间数据
	bool GetCenterClubRoom(const uint64 & room_id, CenterClubRoom * ccRoom);
	// 获得俱乐部房间列表
	uint32 GetCenterClubRoomList(std::list<CenterClubRoom> * lstClubRoom, const char * query,...);
	uint32 GetCenterClubRoomList(std::list<CenterClubRoom> * lstClubRoom, const uint64 & club_id, const uint32 & type = 0);
	//=============================游戏逻辑部分================================
	
	// 创建房间
	bool CreateClubRoom(CharPtr & pChr, const uint64 & club_id, String strData);
	// 请求俱乐部房间列表
	bool GetClubRoomList(CharPtr & pChr, const uint64 & club_id, const uint32 & type = 0);
	// 帧循环事件
	void Update();
	// 房间结束
	void ClubRoomComplate(CenterClubRoom & ccRoom);
	// 玩家创建的俱乐部房间数量是否超限
	bool IsCreateClubRoomOverLimit(CharPtr & pChr);
	// 俱乐部未结束房间数量
	void RunningClubRoomCount(CharPtr & pChr, const uint64 & club_id);
	
private:
	uint32 m_nLastUpdateTimer;
};

#define   sCenterClubRoomMgr     CenterClubRoomManager::getSingleton()


struct CenterClubLabel
{
	uint32 label_id;
	uint32 status;
	uint32 pid;
	uint32 agent_id;
	
	String group_label;
	String remark_label;
	String create_time;
	
	CenterClubLabel()
	{
		Init();
	}
	
	void Init()
	{
		label_id = 0;
		status = 0;
		pid = 0;
		agent_id = 0;
		
		group_label = "";
		remark_label = "";
		create_time = "";
	}
};

enum enOperatorClubLabelResult
{
	enOperatorClubLabelResult_Sucess = 0,				// 成功
	enOperatorClubLabelResult_ErrorIndex = 1,			// 无效的索引
	enOperatorClubLabelResult_ContentTooLong = 2,		// 内容过长
	enOperatorClubLabelResult_ExistLabel = 3,			// 已经存在的标签
	enOperatorClubLabelResult_NotExist = 4,				// 操作的标签不存在
};


// 俱乐部标签（分组，备注）
class  SERVER_DECL CenterClubLabelManager:public Singleton<CenterClubLabelManager>
{
public:
	//==========================资源对象操作相关=================================
	// 添加俱乐部标签
	bool AddCenterClubLabel(CenterClubLabel & ccLabel);
	// 更新房间数据
	bool UpdateCenterClubLabel(const CenterClubLabel & ccLabel);
	// 获得房间数据
	bool GetCenterClubLabel(const uint32 & pid, CenterClubLabel * ccLabel);
	//=============================游戏逻辑部分================================
	
public:
	// 创建标签
	CenterClubLabel CreateCenterClubLabel(CharPtr & pChr);
	// 修改分组标签名字
	bool ChngeClubGroupLabel(CharPtr & pChr, const uint32 & index, String & strData);
	// 检测房间分组是否存在
	bool IsClubGroupLabelExist(CharPtr & pChr, const uint32 & index, String & strLabel);
	// 获取玩家备注信息（包括分组和备注列表）
	bool GetPlayerClubRemarkInfo(CharPtr & pChr);
};

#define   sCenterClubLabelMgr     CenterClubLabelManager::getSingleton()


struct CenterClubRemark
{
	uint32 remark_id;
	uint32 status;
	
	uint32 src_pid;
	String src_nick;
	String src_icon;
	
	uint32 dest_pid;
	String dest_nick;
	String dest_icon;
	
	String remark_info;
	String remark_label;
	String group_label;
	String create_time;
	
	CenterClubRemark()
	{
		Init();
	}
	
	void Init()
	{
		remark_id = 0;
		status = 0;
		
		src_pid = 0;
		src_nick = "";
		src_icon = "";
		
		dest_pid = 0;
		dest_nick = "";
		dest_icon = "";
		
		remark_info = "";
		remark_label = "";
		group_label = "";
		create_time = "";
	}
};

enum enOperatorClubRemarkResult
{
	enOperatorClubRemarkResult_Sucess = 0,				// 成功
	enOperatorClubRemarkResult_ErrorGroup = 1,			// 分组不存在
	enOperatorClubRemarkResult_RemarkTooLong = 2,		// 备注信息过长
	enOperatorClubRemarkResult_NoPid = 3,				// 目标玩家不存在
	enOperatorClubRemarkResult_NotExistRemarkInfo = 4,	// 未找到目标玩家备注信息
	enOperatorClubRemarkResult_CannotOpSelf = 5,		// 不能操作自己
};

// 俱乐部备注信息
class  SERVER_DECL CenterClubRemarkManager:public Singleton<CenterClubRemarkManager>
{
public:
	//==========================资源对象操作相关=================================
	// 添加玩家备注信息
	bool AddCenterClubRemark(CenterClubRemark & ccRemark);
	// 更新玩家备注信息
	bool UpdateCenterClubRemark(const CenterClubRemark & ccRemark);
	bool UpdateCenterClubRemark(Fields * fields, const char * QueryString, ...);
	
	// 获得玩家备注信息
	bool GetCenterClubRemark(const uint32 & src_pid, const uint32 & dest_pid, CenterClubRemark * ccRemark);
	// 获得玩家备注信息列表
	bool GetCenterClubRemarkList(std::list<CenterClubRemark> * lstClubRemark, const uint32 & pid);
	
public:
	//=============================游戏逻辑部分================================
	// 设置玩家备注信息（添加/修改）
	uint8 SetCenterClubRemarkInfo(CharPtr & pChr, const uint32 & dest_pid, const uint32 & groupLabel_id, String & strLabel, String & strData);
	// 移除玩家备注信息
	uint8 RemoveCenterClubRemarkInfo(CharPtr & pChr, const uint32 & dest_pid);
	
};

#define   sCenterClubRemarkMgr     CenterClubRemarkManager::getSingleton()


#endif
